home *** CD-ROM | disk | FTP | other *** search
/ Mission 3 / Mission 3.zip / Mission 3.iso / texte / qed / src / menu.c < prev    next >
C/C++ Source or Header  |  1998-10-29  |  13KB  |  718 lines
  1. #include <errno.h>
  2.  
  3. #include "global.h"
  4. #include "av.h"
  5. #include "block.h"
  6. #include "clipbrd.h"
  7. #include "edit.h"
  8. #include "error.h"
  9. #include "file.h"
  10. #include "find.h"
  11. #include "icon.h"
  12. #include "kurzel.h"
  13. #include "makro.h"
  14. #include "memory.h"
  15. #include "menu.h"
  16. #include "options.h"
  17. #include "printer.h"
  18. #include "projekt.h"
  19. #include "rsc.h"
  20. #include "se.h"
  21. #include "set.h"
  22. #include "text.h"
  23. #include "umbruch.h"
  24. #include "window.h"
  25.  
  26. /****** VARIABLES ************************************************************/
  27.  
  28. /* Menuenummer zu einer Aktion */
  29. int menu_nr[] =    {MUNDO, MCUT, MCOPY, MPASTE, MSELALL, MCLOSE, -1, 
  30.                                    MINFO, -1, MLEFT, MRIGHT, MFORMAT, MPRINT, MABAND, 
  31.                                    MSAVE, MSAVENEW, -1, MFNDGOON, MADD, MGOTO, MSSTRIP,
  32.                                    MSTAB2LZ, -1, MSLZ2TAB, -1, MZEICHEN, MSWAP, MSMALL, 
  33.                                    MBIG, MSMALLBIG, MCAPS, MUMLAUTE, -1, MFEHLERSPRUNG, 
  34.                                    MDELETE, MSORT, MTOPLINE};
  35.  
  36. /*****************************************************************************/
  37.  
  38. static void    mclearup     (void);
  39.  
  40. /*****************************************************************************/
  41. static void info_dial(void)
  42. {
  43.     int    antw;
  44.  
  45.     antw = simple_mdial(about, 0) & 0x7fff;
  46.     if (antw == AINFO)
  47.         simple_mdial(about2, 0);
  48. }
  49.  
  50. /*****************************************************************************/
  51. void    set_overwrite(bool over)
  52. {
  53.     if (overwrite && !over)     /* einfügen */
  54.     {
  55.         overwrite = FALSE;
  56.         menu_icheck(menu, MOOVERW, FALSE);
  57.         menu_icheck(menu, MOEINF, TRUE);
  58.     }
  59.     else                /* überschreiben */
  60.     {
  61.         overwrite = TRUE;
  62.         menu_icheck(menu, MOOVERW, TRUE);
  63.         menu_icheck(menu, MOEINF, FALSE);
  64.     }
  65. }
  66.  
  67. /***************************************************************************/
  68. bool prepare_quit(void)
  69. {
  70.     int    anz, i;
  71.     int    ic, icp[MAX_ICON_ANZ];
  72.     SET    actions;
  73.  
  74.     if (makro_rec)
  75.         return FALSE;
  76.  
  77.     /* Erst alle testen, dann alle killen */
  78.     anz = all_icons(icp);
  79.     i = anz;
  80.     while ((--i)>=0)
  81.     {
  82.         ic = icp[i];
  83.         if (ic!=0)
  84.         {
  85.             icon_exist(ic, actions);
  86.             if (setin(actions, DO_DELETE))
  87.                 if (!icon_test(ic, DO_DELETE))
  88.                     return FALSE;
  89.         }
  90.     }
  91.     if ((!save_opt) != (!shift_pressed()))
  92.         option_save();
  93.     i = anz;
  94.     while ((--i)>=0)
  95.     {
  96.         ic = icp[i];
  97.         if (ic!=0)
  98.         {
  99.             icon_exist(ic, actions);
  100.             if (setin(actions, DO_DELETE))
  101.                 icon_edit(ic, DO_DELETE);
  102.         }
  103.     }
  104.     return TRUE;
  105. }
  106.  
  107. void do_quit(void)
  108. {
  109.     kill_memory();
  110.     done = TRUE;
  111. }
  112.  
  113. /*****************************************************************************/
  114. void set_menu(int item, bool yes)
  115. {
  116.     if (((menu[item].ob_state & DISABLED) == 0) != yes)
  117.         menu_ienable(menu, item, yes);
  118. }
  119.  
  120. void mark_menu(int item, bool yes)
  121. {
  122.     if (((menu[item].ob_state & CHECKED) != 0) != yes)
  123.         menu_icheck(menu, item, yes);
  124. }
  125.  
  126. void fillup_menu(int item, char *new_text, int free)
  127. {
  128.     int    len, max_len;
  129.     char *str;
  130.  
  131.     str = menu[item].ob_spec.free_string + free;
  132.     len = (int) strlen(new_text);
  133.     max_len = (int) strlen(str) - 4;        /* ' ?? ' Shortcut nicht überscrieben! */
  134.     if (len > max_len)
  135.         len = max_len;
  136.     memcpy(str, new_text, len);
  137.     str += len; 
  138.     len = max_len - len;                     /* Restlänge */
  139.     while ((--len) >= 0)
  140.         *str++ = ' ';
  141. }
  142.  
  143. static void set_MCOPY(char *n)
  144. {
  145.     fillup_menu(MCOPY, n, 2);
  146.     set_menu(MCOPY, TRUE);
  147. }
  148.  
  149.  
  150. void update_menu (void)
  151. {
  152.     WINDOWP    window;
  153.     SET        all_actions;
  154.     int        i, nr;
  155.  
  156.     setclr(all_actions);
  157.     window = winlist_top();
  158.  
  159.     if (sel_window != NULL) /* Aktion für selektierte Objekte */
  160.     {
  161.         icon_exist(sel_window->handle + SUB_ICON, all_actions);
  162.         mark_menu(MSEL, FALSE);
  163.         set_menu(MSEL, FALSE);
  164.         set_menu(MSETMARK, FALSE);
  165.     }
  166.     else                            /* Aktionen für oberstes Fenster */
  167.     {
  168.         if (window != NULL)
  169.             icon_exist(window->handle, all_actions);
  170.  
  171.         if (window != NULL && window->class == CLASS_EDIT && 
  172.              !(window->flags & WI_ICONIFIED) && !(window->flags & WI_SHADED))
  173.         {
  174.             TEXTP t_ptr = get_text(window->handle);
  175.  
  176.             mark_menu(MSEL, (!ctrl_mark_mode && t_ptr->blk_mark_mode));
  177.             set_menu(MSEL, !ctrl_mark_mode);
  178.             set_menu(MSETMARK,TRUE);
  179.         }
  180.         else
  181.         {
  182.             mark_menu(MSEL,FALSE);
  183.             set_menu(MSEL,FALSE);
  184.             set_menu(MSETMARK,FALSE);
  185.         }
  186.     }
  187.  
  188.     i = num_openwin(CLASS_ALL);
  189.     set_menu(MCYCLE, ((i >= 2) || wind_cycle));
  190.  
  191.     i = num_openwin(CLASS_EDIT);
  192.     set_menu(MHINTER, (i >= 2));
  193.     set_menu(MNEBEN, (i >= 2));
  194.     set_menu(MUNTER, (i >= 2));
  195.  
  196.     mark_menu(MSRECORD, makro_rec);
  197.  
  198.     for (i = DO_ANZ; (--i) >= 0; )
  199.     {
  200.         nr = menu_nr[i];
  201.         if (nr > -1)
  202.             set_menu(nr, setin(all_actions,i));
  203.     }
  204.     if (setin(all_actions, DO_LINECOPY))
  205.         set_MCOPY(rsc_string(LCOPYSTR));
  206.     else if (setin(all_actions, DO_COPY))
  207.         set_MCOPY(rsc_string(COPYSTR));
  208.  
  209.     setup_semenu();                /* -> se.c */
  210. }
  211.  
  212.  
  213. /***************************************************************************/
  214. static void multitest_action(SET icons, SET action)
  215. {
  216.     int    icp[MAX_ICON_ANZ], ic;
  217.     SET    help;
  218.     int    i;
  219.  
  220.     i = all_icons(icp);
  221.     setclr(action);
  222.     while ((--i)>=0)
  223.     {
  224.         ic = icp[i];
  225.         if(setin(icons,ic))
  226.         {
  227.             icon_exist(ic,help);
  228.             setor(action,help);
  229.         }
  230.     }
  231. }
  232.  
  233. /*****************************************************************************/
  234. static void do_multi_action(int action)
  235. {
  236.     int    icp[MAX_ICON_ANZ], ic;
  237.     SET    sel_icons;
  238.     int    i, anz;
  239.  
  240.     anz = all_icons(icp);
  241.     setcpy(sel_icons, sel_objs);
  242.     for (i=0; i<anz; i++)                /* In dieser Reihenfolge! */
  243.     {
  244.         ic = icp[i];
  245.         if (setin (sel_icons, ic))
  246.         {
  247.             if (do_icon(ic,action)<0 && action==DO_OPEN)
  248.             {
  249.                 note(1, 0, NOWINDOW);
  250.                 break;
  251.             }
  252.         }
  253.     }
  254. }
  255.  
  256. void do_action(int action)
  257. {
  258.     if (sel_window != NULL)            /* Namen in Projekt selektiert */
  259.     {
  260.         if (do_icon(sel_window->handle+SUB_ICON, action) < 0 && action == DO_OPEN)
  261.             note(1, 0, NOWINDOW);
  262.     }
  263.     else
  264.     {
  265.         WINDOWP w = winlist_top();
  266.  
  267.         if (w != NULL)
  268.             do_icon(w->handle,action);
  269.         else
  270.             call_hyp("main");
  271.     }
  272. }
  273.  
  274.  
  275. void menu_help(int title, int item)
  276. {
  277.     char    help[128], str[128];
  278.     int    i;
  279.     
  280.     /* Spezial-Fälle: besonderer Text */
  281.     if (item >= MMARKE1 && item <= MMARKE5)
  282.         strcpy(str, rsc_string(HYPMARKESTR));
  283.     else if (item == MPROJEKT)
  284.         strcpy(str, rsc_string(DEFPRJSTR));
  285.     else if (title == TSHELL)
  286.         strcpy(str, "Shell");
  287.     else if (item >= MHINTER && item <= MUNTER)
  288.         strcpy(str, rsc_string(HYPANORDSTR));
  289.     else
  290.     {
  291.         /* Spezial-Fall: Item ummappen */
  292.         if (item == MOEINF)
  293.             item = MOOVERW;
  294.  
  295.         get_string(menu, item, help);
  296.         
  297.         /* die führenden ' ' überspringen */
  298.         i = 0;
  299.         while (help[i] == ' ')
  300.             i++;
  301.         strcpy(str, help+i);
  302.  
  303.         /* Eintrag endet bei zwei ' ' oder zwei '.' */
  304.         i = 0;
  305.         while (((str[i] != ' ') || (str[i+1] != ' ')) &&
  306.                  ((str[i] != '.') || (str[i+1] != '.')) &&
  307.                  str[i] != EOS)
  308.             i++;
  309.         str[i] = EOS;
  310.     }
  311.     if (str[0] != EOS)
  312.         call_hyp(str);
  313. }
  314.  
  315.  
  316. static bool menu_key(int kstate, int kreturn)
  317. {
  318.     int    title, item;
  319.     
  320.     update_menu();
  321.  
  322.     /* Shift ausblenden wegen global_shift! */
  323.     kstate &= ~(K_LSHIFT|K_RSHIFT);
  324.  
  325.     if (is_menu_key(kreturn, kstate, &title, &item))
  326.     {
  327.         handle_menu(title, item, FALSE);
  328.         return TRUE;
  329.     }
  330.     return FALSE;
  331. }
  332.  
  333.  
  334. /*
  335.  * Globale Tasten auswerten, die übergeordnete Funktionen auslösen.
  336. */
  337. bool    key_global(int kstate, int kreturn)
  338. {
  339.     int    scan;
  340.     
  341.     scan = kreturn >> 8;
  342.     
  343.     wake_mouse();
  344.  
  345.     if (scan == 0x62)            /* HELP */
  346.     {
  347.         do_action(DO_HELP);
  348.         return TRUE;
  349.     }
  350.  
  351.     else if (scan == 0x52)    /* INS: Overwrite toggln, da doppelter Menü-Shortcut */
  352.     {
  353.         set_overwrite(!overwrite);
  354.         return TRUE;
  355.     }
  356.                                     /* Alt+Funktionstasten => Programmende mit Returncode */
  357.     else if ((kstate & K_ALT) && (scan >= 0x3B && scan <= 0x44))
  358.     {
  359.         return_code = (scan - 0x3B) + 1;
  360.         quick_close = TRUE;
  361.         if (prepare_quit())
  362.             do_quit();
  363.         else
  364.             return_code = 0;
  365.         return TRUE;
  366.     }
  367.     
  368.     /* F1-F20: Makro */
  369.     else if ((scan >= 0x3B && scan <= 0x44) || (scan >= 0x54 && scan <= 0x5D))
  370.     {
  371.         /* Makro abspielen */
  372.         if (!start_play(kreturn, 1) && f_to_desk)
  373.             send_avkey(kstate, kreturn);
  374.         return TRUE;
  375.     }
  376.     return (menu_key(kstate, kreturn));
  377. }
  378.  
  379.  
  380. void handle_menu(int title, int item, bool ctrl)
  381. {
  382.     WINDOWP    w;
  383.     int        action, antw, anz;
  384.     char         str[10];
  385.  
  386.     if (ctrl)
  387.         menu_help(title, item);
  388.     else
  389.     {
  390.         w = winlist_top();
  391.         action = -1;
  392.         switch (item)
  393.         {
  394.             case MABOUT :
  395.                 info_dial();
  396.                 break;
  397.  
  398. /* Datei */
  399.             case MNEWTEXT    :
  400.                 new_edit();
  401.                 break;
  402.  
  403.             case MOPEN     :
  404.                 if (sel_window == NULL)
  405.                     select_multi(FALSE);
  406.                 else
  407.                     action = DO_OPEN;
  408.                 break;
  409.  
  410.             case MADD    :
  411.                 action = DO_ADD;
  412.                 break;
  413.  
  414.             case MNEWPROJ :
  415.                 new_projekt();
  416.                 break;
  417.  
  418.             case MOPENBIN :
  419.                 if (sel_window == NULL)
  420.                     select_multi(TRUE);
  421.                 else
  422.                     debug("\aBinOpen aus Projekt geht noch nicht!\n");
  423.                 break;
  424.  
  425.             case MDELETE :
  426.                 action = DO_DELETE;
  427.                 break;
  428.  
  429.             case MSAVE:
  430.                 action = DO_SAVE;
  431.                 break;
  432.  
  433.             case MSAVENEW:
  434.                 action = DO_SAVENEW;
  435.                 break;
  436.  
  437.             case MABAND :
  438.                 action = DO_ABAND;
  439.                 break;
  440.  
  441.             case MPRINT :
  442.                 action = DO_PRINT;
  443.                 break;
  444.  
  445.             case MINFO     :
  446.                 if (w == NULL)
  447.                     info_dial();
  448.                 else
  449.                     action = DO_INFO;
  450.                 break;
  451.  
  452.             case MQUIT2 :
  453.                 quick_close = TRUE;
  454.                 /* kein break! */
  455.             case MQUIT :
  456.                 if (prepare_quit())
  457.                 {
  458.                     menu_tnormal(menu, title, TRUE);
  459.                     do_quit();
  460.                 }
  461.                 break;
  462.  
  463. /* Bearbeiten */
  464.             case MUNDO     :
  465.                 action = DO_UNDO;
  466.                 break;
  467.  
  468.             case MCUT     :
  469.                 action = DO_CUT;
  470.                 break;
  471.  
  472.             case MCOPY     :
  473.                 if (w!=NULL && w->class==CLASS_EDIT)
  474.                 {
  475.                     TEXTP t_ptr = get_text(w->handle);
  476.                     if (t_ptr->block)
  477.                         action = DO_COPY;
  478.                     else
  479.                         action = DO_LINECOPY;
  480.                 }
  481.                 break;
  482.  
  483.             case MPASTE :
  484.                 action = DO_PASTE;
  485.                 break;
  486.  
  487.             case MSEL     :
  488.                 if (w!=NULL && w->class==CLASS_EDIT)
  489.                 {
  490.                     TEXTP t_ptr = get_text(w->handle);
  491.                     if (t_ptr->blk_mark_mode)
  492.                         t_ptr->blk_mark_mode = FALSE;
  493.                     else
  494.                     {
  495.                         blk_demark(t_ptr);
  496.                         restore_edit();
  497.                         blk_mark(t_ptr,0);
  498.                         t_ptr->blk_mark_mode = TRUE;
  499.                     }
  500.                 }
  501.                 break;
  502.  
  503.             case MSELALL :
  504.                 action = DO_SELALL;
  505.                 break;
  506.  
  507.             case MFORMAT :
  508.                 action = DO_FORMAT;
  509.                 break;
  510.  
  511.             case MSWAP:
  512.                 action = DO_SWAPCHAR;
  513.                 break;
  514.  
  515.             case MLEFT     :
  516.                 action = DO_LEFT;
  517.                 break;
  518.  
  519.             case MRIGHT :
  520.                 action = DO_RIGHT;
  521.                 break;
  522.  
  523.             case MSORT :
  524.                 action = DO_SORT;
  525.                 break;
  526.  
  527.             case MSMALLBIG :
  528.                 action = DO_CHNG_SMBG;
  529.                 break;
  530.  
  531.             case MBIG:
  532.                 action = DO_SMALL2BIG;
  533.                 break;
  534.  
  535.             case MSMALL :
  536.                 action = DO_BIG2SMALL;
  537.                 break;
  538.  
  539.             case MCAPS:
  540.                 action = DO_CAPS;
  541.                 break;
  542.  
  543. /* Fenster */
  544.             case MCYCLE :
  545.                 if ((wind_cycle) && (send_avkey(4, 0x1117)))    /* ^W */
  546.                     break;
  547.                 cycle_window();
  548.                 break;
  549.  
  550.             case MCLOSE :
  551.                 action = DO_CLOSE;
  552.                 break;
  553.  
  554.             case MTOPLINE :
  555.                 action = DO_TOPLINE;
  556.                 break;
  557.  
  558.             case MHINTER :
  559.             case MNEBEN :
  560.             case MUNTER :
  561.                 arrange_window(item);
  562.                 break;
  563.  
  564. /* Suchen */
  565.             case MFIND     :
  566.                 action = DO_FIND;
  567.                 break;
  568.  
  569.             case MFNDGOON:
  570.                 action = DO_FINDNEXT;
  571.                 break;
  572.  
  573.             case MFNDFILE :
  574.                 find_on_disk();
  575.                 break;
  576.  
  577.             case MGOTO     :
  578.                 action = DO_GOTO;
  579.                 break;
  580.  
  581.             case MSETMARK:
  582.                 if (w!=NULL)
  583.                     config_marken(get_text(w->handle));
  584.                 break;
  585.  
  586.             case MMARKE1 :
  587.             case MMARKE2 :
  588.             case MMARKE3 :
  589.             case MMARKE4 :
  590.             case MMARKE5 :
  591.                 goto_marke(item-MMARKE1);
  592.                 break;
  593.  
  594. /* Spezial */
  595.             case MSRECORD:
  596.                 if (makro_rec)
  597.                     end_rec(TRUE);
  598.                 else
  599.                     start_rec();
  600.                 break;
  601.  
  602.             case MSPLAY :
  603.                 if (shift_pressed())
  604.                 {
  605.                     set_string(makrorep, MREPANZ, "");
  606.                     antw = simple_mdial(makrorep, MREPANZ);
  607.                     if (antw == MREPOK)
  608.                     {
  609.                         get_string(makrorep, MREPANZ, str);
  610.                         anz = atoi(str);
  611.                     }
  612.                     else
  613.                         break;
  614.                 }
  615.                 else
  616.                     anz = 1;
  617.                 start_play(-1, anz);
  618.                 break;
  619.  
  620.             case MSMAKRO :
  621.                 makro_dial();
  622.                 break;
  623.  
  624.             case MZEICHEN:
  625.                 action = DO_ZEICHTAB;
  626.                 break;
  627.  
  628.             case MUMLAUTE:
  629.                 action = DO_UMLAUT;
  630.                 break;
  631.  
  632.             case MFEHLER:
  633.                 fehler_box();
  634.                 break;
  635.  
  636.             case MFEHLERSPRUNG:
  637.                 action = DO_FEHLER;
  638.                 break;
  639.  
  640.             case MSSTRIP :
  641.                 action = DO_STRIPLINES;
  642.                 break;
  643.  
  644.             case MSTAB2LZ:
  645.                 action = DO_TAB2LZ;
  646.                 break;
  647.  
  648.             case MSLZ2TAB:
  649.                 action = DO_LZ2TAB;
  650.                 break;
  651.  
  652. /* Optionen */
  653.             case MOEINF:
  654.                 set_overwrite(FALSE);
  655.                 break;
  656.  
  657.             case MOOVERW:
  658.                 set_overwrite(TRUE);
  659.                 break;
  660.  
  661.             case MOFONT :
  662.                 select_font();
  663.                 break;
  664.  
  665.             case MGLOBALO:
  666.                 set_global_options();
  667.                 break;
  668.  
  669.             case MLOCALOP:
  670.                 set_local_options();
  671.                 break;
  672.  
  673.             case MAUTOSAVE :
  674.                 set_autosave_options();
  675.                 break;
  676.  
  677.             case MKLAMMER :
  678.                 set_klammer_options();
  679.                 break;
  680.  
  681.             case MPRINTER :
  682.                 prn_cfg_dial();
  683.                 break;
  684.  
  685.             case MPROJEKT :
  686.                 open_def_prj();
  687.                 break;
  688.  
  689.             case MTAKEPRJ :
  690.                 add_to_def();
  691.                 break;
  692.  
  693.             case MSOPTION:
  694.                 option_save();
  695.                  break;
  696.  
  697. /* Shell */
  698.             case MSOPT :
  699.             case MSQUIT :
  700.             case MSMAKEFILE :
  701.             case MSSHELL :
  702.             case MSCOMP :
  703.             case MSMAKE :
  704.             case MSMAKEALL :
  705.             case MSLINK :
  706.             case MSEXEC :
  707.             case MSMAKEEXEC :
  708.                 handle_es(item);
  709.  
  710.             default:
  711.                 break;
  712.         }
  713.         if (action!=-1)
  714.             do_action(action);
  715.     } 
  716.     menu_tnormal(menu, title, TRUE);
  717. }
  718.